package com.tzy.order.service;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 中间类
 */
public class JavaProxyInvocationHandler implements InvocationHandler {
    /**
     * 中间类持有委托类对象的引用,这里会构成一种静态代理关系
     */
    private Object obj ;
    /**
     * 有参构造器,传入委托类的对象
     * @param obj 委托类的对象
     */
    public JavaProxyInvocationHandler(Object obj){
        this.obj = obj;
    }
    /**
     * 动态生成代理类对象,Proxy.newProxyInstance
     * @return 返回代理类的实例
     */
    public Object newProxyInstance() {
        return Proxy.newProxyInstance(
                //指定代理对象的类加载器
                obj.getClass().getClassLoader(),
                //代理对象需要实现的接口，可以同时指定多个接口
                obj.getClass().getInterfaces(),
                //方法调用的实际处理者，代理对象的方法调用都会转发到这里
                (java.lang.reflect.InvocationHandler) this);
    }
    /**
     *
     * @param proxy 代理对象
     * @param method 代理方法
     * @param args 方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("invoke before调用前");
        Object result = method.invoke(obj, args);
        System.out.println("invoke after调用后");
        for(Object o:args){
            System.out.println("o="+o);
        }
        return result;
    }
//    /**
//     * jdk动态代理源码
//     * @param loader
//     * @param interfaces
//     * @param h
//     * @return
//     * @throws IllegalArgumentException
//     */
//    public static Object newProxyInstance(ClassLoader loader,
//                                          Class<?>[] interfaces,
//                                          InvocationHandler h)
//            throws IllegalArgumentException
//    {
//        // 检查空指针
//        Objects.requireNonNull(h);
//        // 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象
//        final Class<?>[] intfs = interfaces.clone();
//        // 获取系统的安全接口,不为空的话需要验证是否允许访问这种关系的代理访问
//        final SecurityManager sm = System.getSecurityManager();
//        if (sm != null) {
//            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
//        }
//
//        /*
//         * 生成代理类 Class,通过类加载器和接口
//         */
//        Class<?> cl = getProxyClass0(loader, intfs);
//
//        /*
//         * 通过构造器来创建实例
//         */
//        try {
//            if (sm != null) {
//                checkNewProxyPermission(Reflection.getCallerClass(), cl);
//            }
//            //获取所有的构造器
//            final Constructor<?> cons = cl.getConstructor(constructorParams);
//            final InvocationHandler ih = h;
//            // 构造器不是public的话需要设置可以访问
//            if (!Modifier.isPublic(cl.getModifiers())) {
//                AccessController.doPrivileged(new PrivilegedAction<Void>() {
//                    public Void run() {
//                        cons.setAccessible(true);
//                        return null;
//                    }
//                });
//            }
//            // 返回创建的代理类Class的实例对象
//            return cons.newInstance(new Object[]{h});
//        } catch (IllegalAccessException|InstantiationException e) {
//            throw new InternalError(e.toString(), e);
//        } catch (InvocationTargetException e) {
//            Throwable t = e.getCause();
//            if (t instanceof RuntimeException) {
//                throw (RuntimeException) t;
//            } else {
//                throw new InternalError(t.toString(), t);
//            }
//        } catch (NoSuchMethodException e) {
//            throw new InternalError(e.toString(), e);
//        }
//    }
}